/**
 * 
 */
package platzerworld.kegeln.db;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import platzerworld.kegeln.db.ergebnis.ErgebnisTbl;
import platzerworld.kegeln.db.klasse.KlasseTbl;
import platzerworld.kegeln.db.mannschaft.MannschaftTbl;
import platzerworld.kegeln.db.spieler.SpielerTbl;
import platzerworld.kegeln.db.verein.VereinTbl;
import platzerworld.kegeln.db.wettkampf.WettkampfTbl;
import platzerworld.kegeln.vo.ergebnis.ErgebnisVO;
import platzerworld.kegelverwaltung.vo.KlasseTO;
import platzerworld.kegelverwaltung.vo.MannschaftTO;
import platzerworld.kegelverwaltung.vo.SpielerTO;
import platzerworld.kegelverwaltung.vo.VereinTO;
import platzerworld.kegelverwaltung.vo.WettkampfTO;
import android.content.Context;
import android.database.sqlite.SQLiteStatement;
import android.os.Environment;
import android.util.Log;
import au.com.bytecode.opencsv.CSVReader;


/**
 * Die Klasse dient als logische Verbindung zur Datenbank der Anwendung. Sie ist f�r die Erstellung und Wartung des Datenbankschemas 
 * sowie die Initialbef�llung der Tabellen verantwortlich.
 * 
 * Die Stammdaten werden �ber einen CSV-Import geliefert.
 * 
 * @author platzerg
 */
public class KegelverwaltungCSVDatenbank extends KegelverwaltungDatenbank {

	/** Markierung f�r Logging. */
	private static final String TAG = "KegelverwaltungGAEDatenbank";

	/**
	 * Die Datenbank kann nur nach Kenntnis "ihrer" Anwendung verwaltet werden.
	 * Daher muss der Context der Anwendung �bergeben werden.
	 * 
	 * @param context Context der aufrufenden Anwendung.
	 */
	public KegelverwaltungCSVDatenbank(Context context) {
		super(context);
	}
		
	/**
	 * Erzeugen der Tabellen.
	 * 
	 * @param context Context der aufrufenden Anwendung.
	 */
	public void initDatabase(Context mContext) {		
		db.execSQL(KlasseTbl.SQL_CREATE);
		db.execSQL(VereinTbl.SQL_CREATE);
		db.execSQL(MannschaftTbl.SQL_CREATE);
		db.execSQL(SpielerTbl.SQL_CREATE);
		db.execSQL(ErgebnisTbl.SQL_CREATE);
		db.execSQL(WettkampfTbl.SQL_CREATE);
	}
	

	/**
	 * Hier werden die Stammdaten f�r die Spielklassen erzeugt.
	 * 
	 * @param deleteOldData true dann werden bestehende Daten gel�scht
	 * 
	 */
	public void erzeugeKlassenDaten( boolean deleteOldData) {
		List<KlasseTO> klassen = new  ArrayList<KlasseTO>();
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
		    	 
				 File klassenFileRead = new File(dir, "klassen.csv");
				 CSVReader klassenCSVReader = new CSVReader(new FileReader(klassenFileRead), '#');
				 List<String[]> klassenEntries = klassenCSVReader.readAll();

				 for (String[] zeile : klassenEntries) {
					 // ID, KLASSE_ID, NAME, SCHUB
					 KlasseTO klasseTO = new KlasseTO();
					 klasseTO.key = Long.parseLong(zeile[0]);
					 klasseTO.klasseId = zeile[1];
					 klasseTO.name = zeile[2];
					 klasseTO.value = zeile[2];
					 klasseTO.schub = zeile[3];
					 
					 klassen.add(klasseTO);
				}
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		try{
			 db = getWritableDatabase();
			 if(null != db){
				// loesche vorhandene Daten
				if(deleteOldData){
					db.delete(KlasseTbl.TABLE_NAME, null, null);
				}

				final SQLiteStatement stmtInsertKlasse = db.compileStatement(KlasseTbl.STMT_KLASSE_INSERT_ALL_WITH_ID);

				db.beginTransaction();
				try {
					for (KlasseTO klasseTO : klassen) {
						stmtInsertKlasse.bindLong(1, klasseTO.key);
						stmtInsertKlasse.bindString(2, klasseTO.klasseId);
						stmtInsertKlasse.bindString(3, klasseTO.name);
						stmtInsertKlasse.bindString(4, klasseTO.schub);
						stmtInsertKlasse.executeInsert();
					}

					db.setTransactionSuccessful();
				} catch (Throwable ex) {
					Log.e(TAG, "Fehler beim Einf�gen eines Klassen-Datensatzes. " + ex);
				} finally {
					db.endTransaction();
				}
			 }
		} finally {
			db.close();
		}

	}

	/**
	 * Hier werden die Stammdaten f�r die Mannschaften erzeugt.
	 * 
	 * @param deleteOldData true dann werden bestehende Daten gel�scht
	 * 
	 */
	public void erzeugeMannschaftDaten(boolean deleteOldData) {
		List<MannschaftTO> mannschaften = new  ArrayList<MannschaftTO>();
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
				 
				 File mannschaftenFileRead = new File(dir, "mannschaften.csv");
				 CSVReader mannschaftenCSVReader = new CSVReader(new FileReader(mannschaftenFileRead), '#');
				 List<String[]> mannschaftenEntries = mannschaftenCSVReader.readAll();

				 for (String[] zeile : mannschaftenEntries) {
					 // ID, KLASSE_ID, VEREIN_ID, NAME, MANNSCHAFT
					 MannschaftTO mannschaftTO = new MannschaftTO();
					 mannschaftTO.id = Long.parseLong(zeile[0]);
					 mannschaftTO.key = Long.parseLong(zeile[0]);
					 mannschaftTO.klasseId = Long.parseLong(zeile[1]);
					 mannschaftTO.vereinId = Long.parseLong(zeile[2]);					 
					 mannschaftTO.name = zeile[3];
					 mannschaftTO.value = zeile[3];					 
					 mannschaftTO.mannschaft = Long.parseLong(zeile[4]);
					 
					 mannschaften.add(mannschaftTO);
				}
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		try{
			db = getWritableDatabase();
			if(null != db){
				if(deleteOldData){
						db.delete(MannschaftTbl.TABLE_NAME, null, null);
				}

				final SQLiteStatement stmtInsertMannschaft = db.compileStatement(MannschaftTbl.STMT_MANNSCHAFT_INSERT_ALL_WIDTH_ID);

				db.beginTransaction();
				try {
					for (MannschaftTO mannschaftTO : mannschaften) {
						stmtInsertMannschaft.bindLong(1, mannschaftTO.id);
						stmtInsertMannschaft.bindString(2, mannschaftTO.name);
						stmtInsertMannschaft.bindLong(3, mannschaftTO.klasseId);
						stmtInsertMannschaft.bindLong(4, mannschaftTO.vereinId);
						stmtInsertMannschaft.bindLong(5, mannschaftTO.mannschaft);
						
						stmtInsertMannschaft.executeInsert();
					}

					db.setTransactionSuccessful();
				} catch (Throwable ex) {
					Log.e(TAG, "Fehler beim Einf�gen eines Mannschaft-Datensatzes. " + ex);
				} finally {
					db.endTransaction();
				}
			 }
		} finally {
			db.close();
		}
	}

	/**
	 * Hier werden die Stammdaten f�r die Spieler erzeugt.
	 * 
	 * @param deleteOldData true dann werden bestehende Daten gel�scht
	 * 
	 */
	public void erzeugeSpielerDaten(boolean deleteOldData) {
		List<SpielerTO> spieler = new  ArrayList<SpielerTO>();
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
				 
				 File spielerFileRead = new File(dir, "spieler.csv");
				 CSVReader spielerCSVReader = new CSVReader(new FileReader(spielerFileRead), '#');
				 List<String[]> spielerEntries = spielerCSVReader.readAll();

				 for (String[] zeile : spielerEntries) {
					 // ID, PASS_NR, MANNSCHAFT_ID, NAME, VORNAME, GEB_DATUM, LOC_LATITUDE, LOC_LONGITUDE
					 SpielerTO spielerTO = new SpielerTO();
					 spielerTO.id = Long.parseLong(zeile[0]);
					 spielerTO.key = Long.parseLong(zeile[0]);
					 spielerTO.passNr = Long.parseLong(zeile[1]);
					 spielerTO.mannschaftId = Long.parseLong(zeile[2]);		
					 spielerTO.aushelfermannschaftId = Long.parseLong(zeile[3]);		
					 spielerTO.name = zeile[4];
					 spielerTO.value = zeile[4];
					 spielerTO.vorname = zeile[5];
					 spielerTO.gebDatum = zeile[6];
					 spielerTO.longitude = Integer.parseInt(zeile[7]);
					 spielerTO.latidute = Integer.parseInt(zeile[8]);
					 
					 spieler.add(spielerTO);
				}
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		try{
			db = getWritableDatabase();
			if(null != db){
				if(deleteOldData){
						db.delete(SpielerTbl.TABLE_NAME, null, null);
				}

				final SQLiteStatement stmtInsertSpieler = db.compileStatement(SpielerTbl.STMT_SPIELER_INSERT_ALL_WITH_ID);

				db.beginTransaction();
				try {
					for (SpielerTO spielerTO : spieler) {						
						stmtInsertSpieler.bindLong(1, spielerTO.id);
						stmtInsertSpieler.bindLong(2, spielerTO.mannschaftId);
						stmtInsertSpieler.bindLong(3, 0);
						stmtInsertSpieler.bindLong(4, spielerTO.passNr);
						stmtInsertSpieler.bindString(5, spielerTO.name);
						stmtInsertSpieler.bindString(6, spielerTO.vorname== null ? "" : spielerTO.vorname);
						stmtInsertSpieler.bindString(7, spielerTO.gebDatum== null ? "" : spielerTO.gebDatum);
						stmtInsertSpieler.bindLong(8, (int) (spielerTO.latidute * 1E6));
						stmtInsertSpieler.bindLong(9, (int) (spielerTO.longitude * 1E6));
						stmtInsertSpieler.executeInsert();
					}

					db.setTransactionSuccessful();
				} catch (Throwable ex) {
					Log.e(TAG, "Fehler beim Einf�gen eines Spieler-Datensatzes. " + ex);
				} finally {
					db.endTransaction();
				}
			 }
		} finally {
			db.close();
		}
		
	}

	/**
	 * Hier werden die Stammdaten f�r die Vereine erzeugt.
	 * 
	 * @param deleteOldData true dann werden bestehende Daten gel�scht
	 * 
	 */
	public void erzeugeVereinDaten(boolean deleteOldData) {

		List<VereinTO> vereine = new  ArrayList<VereinTO>();
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
		    	 
				 File klassenFileRead = new File(dir, "verein.csv");
				 CSVReader vereineCSVReader = new CSVReader(new FileReader(klassenFileRead), '#');
				 List<String[]> vereinEntries = vereineCSVReader.readAll();

				 for (String[] zeile : vereinEntries) {
					 // ID, NAME, CLUB_NUMMER, CLUB, LOC_LONGITUDE, LOC_LATITUDE
					 VereinTO vereinTO = new VereinTO();
					 vereinTO.id = Long.parseLong(zeile[0]);
					 vereinTO.key = Long.parseLong(zeile[0]);
					 vereinTO.name = zeile[1];
					 vereinTO.value = zeile[1];
					 vereinTO.clubnummer =  (int) Long.parseLong(zeile[2]);
					 vereinTO.club = zeile[3];
					 vereinTO.longitude = Integer.parseInt(zeile[4]);
					 vereinTO.latidute = Integer.parseInt(zeile[5]);
					 vereine.add(vereinTO);
				}
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		try{
			 db = getWritableDatabase();
			 if(null != db){
				// loesche vorhandene daten
				if(deleteOldData){
					db.delete(VereinTbl.TABLE_NAME, null, null);
				}

				final SQLiteStatement stmtInsertVerein = db.compileStatement(VereinTbl.STMT_VEREIN_INSERT_ALL_WIDTH_ID);

				db.beginTransaction();
				try {
					for (VereinTO vereinTO : vereine) {
						stmtInsertVerein.bindLong(1, vereinTO.id);
						stmtInsertVerein.bindString(2, vereinTO.name);
						stmtInsertVerein.bindLong(3, 0);
						stmtInsertVerein.bindLong(4, 0);
						stmtInsertVerein.bindLong(5, vereinTO.clubnummer);
						stmtInsertVerein.bindString(6, vereinTO.club);
						stmtInsertVerein.executeInsert();
					}

					db.setTransactionSuccessful();
				} catch (Throwable ex) {
					Log.e(TAG, "Fehler beim Einf�gen eines Verein-Datensatzes. " + ex);
				} finally {
					db.endTransaction();
				}
			 }
		} finally {
			db.close();
		}
	}
	
	/**
	 * Hier werden die Stammdaten f�r die Ergebnisse erzeugt.
	 * 
	 * @param deleteOldData true dann werden bestehende Daten gel�scht
	 * 
	 */
	public void erzeugeErgebnisDaten(boolean deleteOldData) {

		List<ErgebnisVO> ergebnisse = new  ArrayList<ErgebnisVO>();
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
		    	 
				 File ergebnisseFileRead = new File(dir, "ergebnis.csv");
				 CSVReader ergebnisseCSVReader = new CSVReader(new FileReader(ergebnisseFileRead), '#');
				 List<String[]> ergebnisseEntries = ergebnisseCSVReader.readAll();

				 for (String[] zeile : ergebnisseEntries) {
					 // ID, SPIEL_ID, SPIELER_ID, MANNSCHAFT_ID, SPIEL_ZEIT, 
					 // ERGEBNIS_50_1, ERGEBNIS_50_2, VOLLE_25_1, VOLLE_25_2, ABRAEUMEN_25_1, ABRAEUMEN_25_2, FEHL_25_1,  
					 // FEHL_25_2GESAMT_ERGEBNIS
					 ErgebnisVO ergebnisVO = new ErgebnisVO();
					 ergebnisVO.key = Long.parseLong(zeile[0]);
					 ergebnisVO.spielId = Long.parseLong(zeile[1]);					 
					 ergebnisVO.spielerId = Long.parseLong(zeile[2]);
					 ergebnisVO.mannschaftId = Long.parseLong(zeile[3]);					 
					 ergebnisVO.spielZeit = zeile[4];						 
					 ergebnisVO.ergebnis501 = Long.parseLong(zeile[5]);
					 ergebnisVO.ergebnis502 = Long.parseLong(zeile[6]);
					 ergebnisVO.volle251 = Long.parseLong(zeile[7]);
					 ergebnisVO.volle252 = Long.parseLong(zeile[8]);
					 ergebnisVO.abraeumen251 = Long.parseLong(zeile[9]);
					 ergebnisVO.abraeumen252 = Long.parseLong(zeile[10]);
					 ergebnisVO.fehl251 = Long.parseLong(zeile[11]);
					 ergebnisVO.fehl252 = Long.parseLong(zeile[12]);					 
					 ergebnisVO.gesamtergebnis = Long.parseLong(zeile[13]);
					 
					 ergebnisse.add(ergebnisVO);
				}
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		try{
			 db = getWritableDatabase();
			 if(null != db){
				// loesche vorhandene daten
				if(deleteOldData){
					db.delete(ErgebnisTbl.TABLE_NAME, null, null);
				}

				final SQLiteStatement stmtInsertErgebnis = db.compileStatement(ErgebnisTbl.STMT_MAX_INSERT);

				db.beginTransaction();
				try {
					for (ErgebnisVO ergebnisVO : ergebnisse) {
						stmtInsertErgebnis.bindLong(1, ergebnisVO.spielId);
						stmtInsertErgebnis.bindLong(2, ergebnisVO.spielerId);
						stmtInsertErgebnis.bindString(3, ergebnisVO.spielZeit);
						stmtInsertErgebnis.bindLong(4, ergebnisVO.mannschaftId);
						
						stmtInsertErgebnis.bindLong(5, ergebnisVO.gesamtergebnis);
						stmtInsertErgebnis.bindLong(6, ergebnisVO.ergebnis501);
						stmtInsertErgebnis.bindLong(7, ergebnisVO.ergebnis502);
						stmtInsertErgebnis.bindLong(8, ergebnisVO.volle251);
						stmtInsertErgebnis.bindLong(9, ergebnisVO.volle252);
						stmtInsertErgebnis.bindLong(10, ergebnisVO.abraeumen251);
						stmtInsertErgebnis.bindLong(11, ergebnisVO.abraeumen252);
						stmtInsertErgebnis.bindLong(12, ergebnisVO.fehl251);
						stmtInsertErgebnis.bindLong(13, ergebnisVO.fehl252);

						stmtInsertErgebnis.executeInsert();
					}

					db.setTransactionSuccessful();
				} catch (Throwable ex) {
					Log.e(TAG, "Fehler beim Einf�gen eines Ergebnis-Datensatzes. " + ex);
				} finally {
					db.endTransaction();
				}
			 }
		} finally {
			db.close();
		}
	}
	
	/**
	 * Hier werden die Stammdaten f�r die Wettk�mpfe erzeugt.
	 * 
	 * @param deleteOldData true dann werden bestehende Daten gel�scht
	 * 
	 */
	public void erzeugeWettkampfDaten(boolean deleteOldData) {

		List<WettkampfTO> wettkaempfe = new  ArrayList<WettkampfTO>();
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
		    	 
				 File klassenFileRead = new File(dir, "wettkampf.csv");
				 CSVReader wettkaempfeCSVReader = new CSVReader(new FileReader(klassenFileRead), '#');
				 List<String[]> vereinEntries = wettkaempfeCSVReader.readAll();

				 for (String[] zeile : vereinEntries) {
					 // ID, SPIEL_NR, HEIM_ID, GAST_ID, KLASSE_ID, SPIEL_ZEIT, PAARUNG_1, PAARUNG_1_ERGEBNIS_HEIM, PAARUNG_1_ERGEBNIS_GAST, 
					 // PAARUNG_2, PAARUNG_2_ERGEBNIS_HEIM, PAARUNG_2_ERGEBNIS_GAST, PAARUNG_3, PAARUNG_3_ERGEBNIS_HEIM, PAARUNG_3_ERGEBNIS_GAST, 
					 // PAARUNG_4, PAARUNG_4_ERGEBNIS_HEIM, PAARUNG4_ERGEBNIS_GAST, PAARUNG_5, PAARUNG_5_ERGEBNIS_HEIM, PAARUNG_5_ERGEBNIS_GAST, 
					 // PAARUNG_6, PAARUNG_6_ERGEBNIS_HEIM, PAARUNG_6_ERGEBNIS_GAST, GESAMT_ERGEBNIS
					 WettkampfTO wettkampfTO = new WettkampfTO();
					 wettkampfTO.key = Long.parseLong(zeile[0]); // WettkampfTbl.ID
					 wettkampfTO.spielNr = Long.parseLong(zeile[1]); // WettkampfTbl.SPIEL_NR
					 wettkampfTO.heimId = Long.parseLong(zeile[2]); // WettkampfTbl.HEIM_ID
					 wettkampfTO.gastId = Long.parseLong(zeile[3]); // WettkampfTbl.GAST_ID
					 wettkampfTO.klasseId = Long.parseLong(zeile[4]); // WettkampfTbl.KLASSE_ID
					 
					 wettkampfTO.spielZeit = zeile[5]; // WettkampfTbl.SPIEL_ZEIT
					 
					 wettkampfTO.paarung1 = zeile[6]; // WettkampfTbl.PAARUNG_1
					 wettkampfTO.paarung1ErgebnisHeim = Long.parseLong(zeile[7]); // WettkampfTbl.PAARUNG_1_ERGEBNIS_HEIM
					 wettkampfTO.paarung1ErgebnisGast = Long.parseLong(zeile[8]); // WettkampfTbl.PAARUNG_1_ERGEBNIS_GAST
					 
					 wettkampfTO.paarung2 = zeile[9]; // WettkampfTbl.PAARUNG_2
					 wettkampfTO.paarung2ErgebnisHeim = Long.parseLong(zeile[10]); // WettkampfTbl.PAARUNG_2_ERGEBNIS_HEIM
					 wettkampfTO.paarung2ErgebnisGast = Long.parseLong(zeile[11]); // WettkampfTbl.PAARUNG_2_ERGEBNIS_GAST
					 
					 wettkampfTO.paarung3 = zeile[12]; // WettkampfTbl.PAARUNG_3
					 wettkampfTO.paarung3ErgebnisHeim = Long.parseLong(zeile[13]); // WettkampfTbl.PAARUNG_3_ERGEBNIS_HEIM
					 wettkampfTO.paarung3ErgebnisGast = Long.parseLong(zeile[14]); // WettkampfTbl.PAARUNG_3_ERGEBNIS_GAST
					 
					 wettkampfTO.paarung4 = zeile[15]; // WettkampfTbl.PAARUNG_4
					 wettkampfTO.paarung4ErgebnisHeim = Long.parseLong(zeile[16]); // WettkampfTbl.PAARUNG_4_ERGEBNIS_HEIM
					 wettkampfTO.paarung4ErgebnisGast = Long.parseLong(zeile[17]); // WettkampfTbl.PAARUNG_4_ERGEBNIS_GAST
					 
					 wettkampfTO.paarung5 = zeile[18]; // WettkampfTbl.PAARUNG_5
					 wettkampfTO.paarung5ErgebnisHeim = Long.parseLong(zeile[19]); // WettkampfTbl.PAARUNG_5_ERGEBNIS_HEIM
					 wettkampfTO.paarung5ErgebnisGast = Long.parseLong(zeile[20]); // WettkampfTbl.PAARUNG_5_ERGEBNIS_GAST
					 
					 wettkampfTO.paarung6 = zeile[21]; // WettkampfTbl.PAARUNG_6
					 wettkampfTO.paarung6ErgebnisHeim = Long.parseLong(zeile[22]); // WettkampfTbl.PAARUNG_6_ERGEBNIS_HEIM
					 wettkampfTO.paarung6ErgebnisGast = Long.parseLong(zeile[23]); // WettkampfTbl.PAARUNG_6_ERGEBNIS_GAST

					 wettkampfTO.gesamtErgebnis = zeile[24]; // WettkampfTbl.GESAMT_ERGEBNIS
					 
					 wettkaempfe.add(wettkampfTO);
				}
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		try{
			 db = getWritableDatabase();
			 if(null != db){
				// loesche vorhandene daten
				if(deleteOldData){
					db.delete(VereinTbl.TABLE_NAME, null, null);
				}

				final SQLiteStatement stmtInsertWettkampf = db.compileStatement(WettkampfTbl.STMT_WETTKAMPF_INSERT_ALL_WIDT_ID);

				db.beginTransaction();
				try {
					for (WettkampfTO wettkampfTO : wettkaempfe) {
						stmtInsertWettkampf.bindLong(1, wettkampfTO.key);
						stmtInsertWettkampf.bindLong(2, wettkampfTO.spielNr);
						stmtInsertWettkampf.bindLong(3, wettkampfTO.heimId);
						stmtInsertWettkampf.bindLong(4, wettkampfTO.gastId);
						stmtInsertWettkampf.bindLong(5, wettkampfTO.klasseId);
						stmtInsertWettkampf.bindString(6, wettkampfTO.spielZeit);
						
						stmtInsertWettkampf.bindString(7, wettkampfTO.paarung1);
						stmtInsertWettkampf.bindLong(8, wettkampfTO.paarung1ErgebnisHeim);
						stmtInsertWettkampf.bindLong(9, wettkampfTO.paarung1ErgebnisGast);
						
						stmtInsertWettkampf.bindString(10, wettkampfTO.paarung2);
						stmtInsertWettkampf.bindLong(11, wettkampfTO.paarung2ErgebnisHeim);
						stmtInsertWettkampf.bindLong(12, wettkampfTO.paarung2ErgebnisGast);
						
						stmtInsertWettkampf.bindString(13, wettkampfTO.paarung3);
						stmtInsertWettkampf.bindLong(14, wettkampfTO.paarung3ErgebnisHeim);
						stmtInsertWettkampf.bindLong(15, wettkampfTO.paarung3ErgebnisGast);
						
						stmtInsertWettkampf.bindString(16, wettkampfTO.paarung4);
						stmtInsertWettkampf.bindLong(17, wettkampfTO.paarung4ErgebnisHeim);
						stmtInsertWettkampf.bindLong(18, wettkampfTO.paarung4ErgebnisGast);
						
						stmtInsertWettkampf.bindString(19, wettkampfTO.paarung5);
						stmtInsertWettkampf.bindLong(20, wettkampfTO.paarung5ErgebnisHeim);
						stmtInsertWettkampf.bindLong(21, wettkampfTO.paarung5ErgebnisGast);
						
						stmtInsertWettkampf.bindString(22, wettkampfTO.paarung6);
						stmtInsertWettkampf.bindLong(23, wettkampfTO.paarung6ErgebnisHeim);
						stmtInsertWettkampf.bindLong(24, wettkampfTO.paarung6ErgebnisGast);
						
						stmtInsertWettkampf.bindString(25, wettkampfTO.gesamtErgebnis);
						
						stmtInsertWettkampf.executeInsert();
					}

					db.setTransactionSuccessful();
				} catch (Throwable ex) {
					Log.e(TAG, "Fehler beim Einf�gen eines WettkampfDatensatzes. " + ex);
				} finally {
					db.endTransaction();
				}
			 }
		} finally {
			db.close();
		}
	}

}
